package br.skytef.stmanager.utils;

import java.sql.SQLException;

import javax.faces.context.FacesContext;
import javax.servlet.http.HttpSession;

import org.eclipse.persistence.exceptions.SessionLoaderException;

import br.skytef.stmanager.beans.LoginBean;
import br.skytef.stmanager.daos.ClienteDAO;
import br.skytef.stmanager.daos.ControlPlanilhaDAO;
import br.skytef.stmanager.daos.DivergenciaClienteDao;
import br.skytef.stmanager.daos.ErroPlanilhaDAO;
import br.skytef.stmanager.daos.ProdutoClienteDao;
import br.skytef.stmanager.entities.ClienteEntity;
import br.skytef.stmanager.entities.ControlPlanilhasEntity;
import br.skytef.stmanager.entities.DivergenciaClienteEntity;
import br.skytef.stmanager.entities.ErroPlanilhaEntity;
import br.skytef.stmanager.entities.ProdutoClienteEntity;
import br.skytef.stmanager.entities.UsuarioEntity;

public class ImportandoExternos implements Runnable {

	private PlanLyra  planilhaL;
	public PlanLyra getPlanilhaL() {return planilhaL;}
	public void setPlanilhaL(PlanLyra planilhaL) {this.planilhaL = planilhaL;}

	private PlanGsurf planilhaG;
	public PlanGsurf getPlanilhaG() {return planilhaG;}
	public  void setPlanilhaG(PlanGsurf planilhaG) {this.planilhaG = planilhaG;}

	private PlanSE planilhaS;
	public PlanSE getPlanilhaS() {return planilhaS;}
	public void setPlanilhaS(PlanSE planilhaS) {this.planilhaS = planilhaS;}

	private String nomePlanilha;
	public String getNomePlanilha() {return nomePlanilha;}
	public void setNomePlanilha(String nomePlanilha) {this.nomePlanilha = nomePlanilha;}

	private UsuarioEntity usuario;
	public UsuarioEntity getUsuario() {return usuario;}
	public void setUsuario(UsuarioEntity usuarioEntity) {this.usuario = usuarioEntity;}

	private ControlPlanilhasEntity cp;
	private double totalLyra = 0;
	private double totalGSurf = 0;
	private double totalSE = 0;

	public ImportandoExternos() {
		super();
		try {
			FacesContext ctx = FacesContext.getCurrentInstance();
			HttpSession session = (HttpSession) ctx.getExternalContext().getSession(false);
			usuario = (UsuarioEntity)session.getAttribute("usuario");
			if(usuario == null){
				new LoginBean().encerraSessao();
			}
		}catch(SessionLoaderException e){ 
			new LoginBean().encerraSessao();
		}
	}
	@Override
	public void run() {

		if (planilhaL != null && planilhaL.validar()){
			iniciarControle(planilhaL);
			for(int i=1; i < planilhaL.qtlinha(); i++){
				try{
					planilhaL.importarlinha(i);
					ClienteEntity cliente = new ClienteDAO().buscarCliente(planilhaL.getCnpj());
					if(cliente != null){
						totalLyra += planilhaL.getValorPonto();
						double somatoria = cliente.getValorLyra();
						somatoria += planilhaL.getValorPonto();
						cliente.setValorLyra(somatoria);
						new ClienteDAO().alterar(cliente);
						ProdutoClienteEntity prodCliente = new ProdutoClienteDao().localizar(cliente.getIdCliente());
						if(prodCliente != null){
							prodCliente.setTipoVpn("Lyra");
							prodCliente.setSerial(planilhaL.getSerial());
							new ProdutoClienteDao().alterar(prodCliente);
						}
						if(planilhaL.getValorPonto() >= cliente.getValorFaturado()){
							divergencia(nomePlanilha, planilhaL.getValorPonto(), cliente.getIdCliente(), "divgValor");
						}	

					}else if(planilhaL.getCnpj() != 0){
						cliente = new ClienteEntity();
						cliente.setCnpj(planilhaL.getCnpj());
						int id  = (int) cliente.getCnpj();
						if(id < 0)
							id *= -1;
						cliente.setIdCliente(id);
						cliente.setRazaoSocial(planilhaL.getRazaoSocial());
						cliente.setValorLyra(planilhaL.getValorPonto());
						cliente.setUsuario_id(usuario.getId());
						new ClienteDAO().inserir(cliente);
						divergencia(nomePlanilha, planilhaL.getValorPonto(), cliente.getIdCliente(), "Lyra");

					}else{
						inserirErro(planilhaL);
					}
				}catch (Exception e){
					inserirErro(planilhaL);
				}				
			}
			cp.setTotalLyra(totalLyra);
		}else if (planilhaG != null && planilhaG.validar()){
			iniciarControle(planilhaG);
			for(int i=1; i < planilhaG.qtlinha(); i++){
				try{
					planilhaG.importarlinha(i);
					ClienteEntity cliente = new ClienteDAO().buscarCliente(planilhaG.getCnpj());
					if(cliente != null){
						totalGSurf += planilhaG.getValorMensal();
						cliente.setCidade(planilhaG.getCidade());
						cliente.setUf(planilhaG.getUf());
						cliente.setPolitica(planilhaG.getPolitica());
						cliente.setCategoria(planilhaG.getCategoria());
						double somatoria = cliente.getValorGSurf();
						somatoria+=planilhaG.getValorMensal();
						cliente.setValorGSurf(somatoria);
						new ClienteDAO().alterar(cliente);
						ProdutoClienteEntity prodCliente = new ProdutoClienteDao().localizar(cliente.getIdCliente());
						if(prodCliente != null){
							prodCliente.setTerminal(planilhaG.getTerminal());
							prodCliente.setTipoVpn("GSurf");
							new ProdutoClienteDao().alterar(prodCliente);
						}
						if(planilhaG.getValorMensal() >= cliente.getValorFaturado()){
							divergencia(nomePlanilha, planilhaG.getValorMensal(), cliente.getIdCliente(), "divgValor");
						}
					}else if(planilhaG.getCnpj() != 0){
						cliente = new ClienteEntity();
						cliente.setCnpj(planilhaG.getCnpj());
						int id  = (int) cliente.getCnpj();
						if(id < 0)
							id *= -1;
						cliente.setIdCliente(id);
						cliente.setRazaoSocial(planilhaG.getRazaoSocial());
						cliente.setCidade(planilhaG.getCidade());
						cliente.setUf(planilhaG.getUf());
						cliente.setPolitica(planilhaG.getPolitica());
						cliente.setCategoria(planilhaG.getCategoria());
						cliente.setValorGSurf(planilhaG.getValorMensal());
						cliente.setUsuario_id(usuario.getId());
						new ClienteDAO().inserir(cliente);
						divergencia(nomePlanilha, planilhaG.getValorMensal(), cliente.getIdCliente(), "GSurf");
					}else{
						inserirErro(planilhaG);
					}
				}catch (Exception e){
					inserirErro(planilhaG);
				}
			}	
			cp.setTotalGSurf(totalGSurf);
		}else if (planilhaS != null && planilhaS.validar()){
			iniciarControle(planilhaS);
			for(int i=1; i < planilhaS.qtlinha(); i++){
				planilhaS.importarlinha(i);
				ClienteEntity cliente = new ClienteDAO().buscarCliente(planilhaS.getCnpj());
				if(cliente != null){
					totalSE += planilhaS.getValor();
					double somatoria = cliente.getValorSE();
					somatoria += planilhaS.getValor();
					cliente.setValorSE(somatoria);
					ProdutoClienteEntity prodCliente = new ProdutoClienteDao().localizar(cliente.getIdCliente());
					if(prodCliente != null){
						prodCliente.setDataAtivacao(planilhaS.getData());
						new ProdutoClienteDao().alterar(prodCliente);
					}							
					try {
						new ClienteDAO().alterar(cliente);
					} catch (SQLException e) {
						inserirErro(planilhaS);
					}
					if(planilhaS.getValor() >= cliente.getValorFaturado()){
						divergencia(nomePlanilha, planilhaS.getValor(), cliente.getIdCliente(), "divgValor");
					}else if(planilhaS.getQtdLoja() != cliente.getQtdLojas()){
						divergencia(nomePlanilha, planilhaS.getQtdLoja(), cliente.getIdCliente(), "divgLoja");
					}					
				}else if(planilhaS.getCnpj() !=0){
					cliente = new ClienteEntity();
					cliente.setCnpj(planilhaS.getCnpj());
					int id  = (int) cliente.getCnpj();
					if(id < 0)
						id *= -1;
					cliente.setIdCliente(id);
					cliente.setRazaoSocial(planilhaS.getRazaSocialCliente());
					cliente.setQtdLojas(planilhaS.getQtdLoja());
					cliente.setValorSE(planilhaS.getValor());
					cliente.setUsuario_id(usuario.getId());
					try {
						new ClienteDAO().inserir(cliente);
					} catch (SQLException e) {
						inserirErro(planilhaS);
					}
					divergencia(nomePlanilha, planilhaS.getValor(), cliente.getIdCliente(), "SE");					
				}else{
					inserirErro(planilhaS);
				}
			}
			cp.setTotalSE(totalSE);
		}
		new ControlPlanilhaDAO().inserirAtualizar(cp);
	}

	private void divergencia(String plan, double valor, int cliente, String tipo){
		DivergenciaClienteEntity DCE = new DivergenciaClienteDao().buscar(cliente);
		if(DCE != null){
			DCE.setNomePlanilha(plan);
			DCE.setValor(valor);
			DCE.setData_divergencia(new Data().DtTime());
			DCE.setTipo(tipo);
		}else{
			DCE = new DivergenciaClienteEntity(plan, valor, tipo, new Data().DtTime(), cliente);
			new DivergenciaClienteDao().inserir(DCE);
		}
	}

	private void iniciarControle(PlanLyra plan){
		try {
			cp = new ControlPlanilhasEntity(3,nomePlanilha, plan.qtlinha()-1, 0, new Data().DtTime(),0,0.0,0.0,0.0,0.0);
			new ErroPlanilhaDAO().delete(cp.getIdcontrolPlanilha());
			new ClienteDAO().limparValorLyra();
			new DivergenciaClienteDao().limpar(nomePlanilha);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	private void inserirErro(PlanLyra plan){
		cp.setErros(cp.getErros() + 1);
		cp.setLinhasImportadas(cp.getLinhasImportadas() - 1);
		new ControlPlanilhaDAO().inserirAtualizar(cp);
		new ErroPlanilhaDAO().inserir(new ErroPlanilhaEntity(3, plan.getLinhaErrada()));

	}

	private void iniciarControle(PlanGsurf plan){
		try {
			cp = new ControlPlanilhasEntity(4,nomePlanilha, plan.qtlinha()-1, 0, new Data().DtTime(),0,0.0,0.0,0.0,0.0);
			new ErroPlanilhaDAO().delete(cp.getIdcontrolPlanilha());
			new ClienteDAO().limparValorGSurf();
			new DivergenciaClienteDao().limpar(nomePlanilha);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	private void inserirErro(PlanGsurf plan){
		cp.setErros(cp.getErros() + 1);
		cp.setLinhasImportadas(cp.getLinhasImportadas() - 1);
		new ControlPlanilhaDAO().inserirAtualizar(cp);
		new ErroPlanilhaDAO().inserir(new ErroPlanilhaEntity(4, plan.getLinhaErrada()));

	}
	private void iniciarControle(PlanSE plan){
		try {
			cp = new ControlPlanilhasEntity(5,nomePlanilha, plan.qtlinha()-1, 0, new Data().DtTime(),0,0.0,0.0,0.0,0.0);
			new ErroPlanilhaDAO().delete(cp.getIdcontrolPlanilha());
			new ClienteDAO().limparValorSE();
			new DivergenciaClienteDao().limpar(nomePlanilha);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	private void inserirErro(PlanSE plan){
		cp.setErros(cp.getErros() + 1);
		cp.setLinhasImportadas(cp.getLinhasImportadas() - 1);
		new ErroPlanilhaDAO().inserir(new ErroPlanilhaEntity(5, plan.getLinhaErrada()));
		new ControlPlanilhaDAO().inserirAtualizar(cp);
	}

}
